// zgsprite.h - 少儿编程教学库
// 封装了精灵类(Sprite)和画笔类(Pen)，方便孩子们创建游戏角色和在屏幕上绘画

#ifndef ZGSPRITE_H
#define ZGSPRITE_H

#include <raylib.h>
#include "rlgl.h"
#include <string>
#include <vector>
#include <cmath>

// 前向声明
class Sprite;
class Pen;

// ===== 精灵类 =====
class Sprite {
public:
    // 构造函数 - 创建一个精灵
    Sprite(const std::string& imagePath = "") {
        position = { 0, 0 };
        rotation = 0.0f;
        scale = 1.0f;
        visible = true;

        if (!imagePath.empty()) {
            texture = LoadTexture(imagePath.c_str());
            width = texture.width;
            height = texture.height;
            hasTexture = true;
        }
        else {
            width = 50;
            height = 50;
            hasTexture = false;
            color = RED;
        }
    }


    // 设置精灵位置（基于中心点）
    void SetPosition(float x, float y) {
        position.x = x + width * scale / 2;
        position.y = y - height * scale / 2;
    }

    // 移动精灵
    void Move(float dx, float dy) {
        position.x += dx;
        position.y += dy;
    }

    // 旋转精灵
    void Rotate(float angle) {
        rotation += angle;
    }

    // 设置旋转角度
    void SetRotation(float angle) {
        rotation = angle;
    }

    // 设置缩放比例
    void SetScale(float s) {
        scale = s;
    }

    // 设置颜色（用于没有纹理的精灵）
    void SetColor(Color c) {
        color = c;
    }

    // 显示精灵
    void Show() {
        visible = true;
    }

    // 隐藏精灵
    void Hide() {
        visible = false;
    }

    // 绘制精灵
    void Draw() {
        if (!visible) return;

        if (hasTexture) {
            // 计算绘制参数
            Rectangle source = { 0, 0, (float)texture.width, (float)texture.height };
            Rectangle dest = { position.x, position.y, width * scale, height * scale };
            Vector2 origin = { width * scale / 2, height * scale / 2 };

            // 绘制纹理
            DrawTexturePro(texture, source, dest, origin, rotation, WHITE);
        }
        else {
            // 没有纹理时绘制一个矩形
            Rectangle rect = { position.x - width * scale / 2, position.y - height * scale / 2,
                             width * scale, height * scale };
            DrawRectanglePro(rect, { width * scale / 2, height * scale / 2 }, rotation, color);
        }
    }

    // 获取位置
    Vector2 GetPosition() const {
        return { position.x - this->width * this->scale / 2, position.y - this->height * this->scale / 2 };
    }

    // 获取旋转角度
    float GetRotation() const {
        return rotation;
    }

    // 碰撞检测
    bool IsColliding(const Sprite& other) const {
        // 简单的圆形碰撞检测
        float dx = position.x - other.position.x;
        float dy = position.y - other.position.y;
        float distance = sqrt(dx * dx + dy * dy);
        float minDist = (width + other.width) * scale * 0.4f;

        return distance < minDist;
    }

private:
    Texture2D texture;      // 精灵纹理
    Vector2 position;       // 位置
    float rotation;         // 旋转角度
    float scale;            // 缩放比例
    float width, height;    // 宽度和高度
    bool visible;           // 是否可见
    bool hasTexture;        // 是否有纹理
    Color color;            // 颜色（无纹理时使用）
};

// ===== 画笔类 =====
class Pen {
public:
    // 构造函数
    Pen() {
        position = { 400, 300 };  // 默认在屏幕中央
        angle = 0.0f;
        color = BLACK;
        thickness = 2.0f;
        penDown = true;
        width = 50;
        height = 50;
        scale = 1.0f;

        // 使用默认字体
        font = GetFontDefault();
    }

    // 析构函数
    ~Pen() {
        // 无需释放默认字体
    }

    // 设置画笔位置
    void SetPosition(float x, float y) {
        if (penDown) {
            DrawLineEx({ position.x, position.y }, { x, y }, thickness, color);
        }
        position.x = x;
        position.y = y;
    }

    // 移动画笔
    void Move(float distance) {
        float radians = angle * DEG2RAD;
        float newX = position.x + cos(radians) * distance;
        float newY = position.y + sin(radians) * distance;

        if (penDown) {
            DrawLineEx({ position.x, position.y }, { newX, newY }, thickness, color);
        }

        position.x = newX;
        position.y = newY;
    }

    // 旋转画笔
    void Rotate(float degrees) {
        angle += degrees;
    }

    // 设置旋转角度
    void SetAngle(float degrees) {
        angle = degrees;
    }

    // 设置颜色
    void SetColor(Color c) {
        color = c;
    }

    // 设置线条粗细
    void SetThickness(float t) {
        thickness = t;
    }

    // 抬起画笔
    void PenUp() {
        penDown = false;
    }

    // 放下画笔
    void PenDown() {
        penDown = true;
    }

    // 绘制线条
    void DrawLine(float x1, float y1, float x2, float y2) {
        DrawLineEx({ x1, y1 }, { x2, y2 }, thickness, color);
    }

    // 绘制矩形
    void DrawRectangle(float x, float y, float width, float height) {
        DrawRectangleLines(x, y, width, height, color);
    }

    // 绘制填充矩形
    void DrawFilledRectangle(float x, float y, float width, float height) {
        DrawRectangleRec({ x, y, width, height }, color);
    }

    // 绘制圆形
    void DrawCircle(float x, float y, float radius) {
        DrawCircleLines(x, y, radius, color);
    }

    // 绘制填充圆形
    void DrawFilledCircle(float x, float y, float radius) {
        ::DrawCircle(x, y, radius, color);
    }

    // 绘制文字（支持中文和默认字体）
    void DrawText(const std::string& text = "", Vector2 pos = { 0,0 }, int fontSize = 20, Color color = BLACK, const std::string& fontPath = "") {
        unsigned int fileSize;
        unsigned char* fontFileData = LoadFileData(fontPath.c_str(), &fileSize);
        int codepointsCount;
        int* codepoints = LoadCodepoints(text.c_str(), &codepointsCount);
        Font font = LoadFontFromMemory(".ttf", fontFileData, 32, fontSize, codepoints, codepointsCount);
        DrawTextEx(font, text.c_str(), pos, fontSize, 2, color);
        delete fontFileData;
    }
    // 绘制带背景的文字（仅支持英文）
    void DrawTextWithBackground(const std::string& text = "", Vector2 pos = { 0,0 }, int fontSize = 20, Color bgColor = WHITE, const std::string& fontPath = "") {
        int textWidth = MeasureText(text.c_str(), fontSize);
        auto [x, y] = pos;
        DrawRectangleRec({ x - 5, y - 5, (float)(textWidth + 10), (float)(fontSize + 10) }, bgColor);
        DrawText(text.c_str(), pos, fontSize, color, fontPath);
    }

    // 获取位置
    Vector2 GetPosition() const {
        return { position.x - this->width * this->scale / 2, position.y - this->height * this->scale / 2 };
    }

    // 获取角度
    float GetAngle() const {
        return angle;
    }

    // 获取线条粗细
    float GetThickness() const {
        return thickness;
    }

    // 检查画笔是否落下
    bool IsPenDown() const {
        return penDown;
    }

    // ==== 海龟绘图功能 ====
    // 向前移动
    void Forward(float distance) {
        Move(distance);
    }

    // 向后移动
    void Backward(float distance) {
        Move(-distance);
    }

    // 向左转
    void TurnLeft(float degrees) {
        Rotate(-degrees);
    }

    // 向右转
    void TurnRight(float degrees) {
        Rotate(degrees);
    }

    // 设置绝对角度（0=向右，90=向上）
    void SetHeading(float degrees) {
        angle = degrees;
    }

    // 获取当前角度
    float GetHeading() const {
        return angle;
    }

private:
    Vector2 position;   // 画笔位置
    float angle;        // 画笔角度
    Color color;        // 画笔颜色
    float thickness;    // 线条粗细
    bool penDown;       // 画笔是否落下
    Font font;          // 使用默认字体
    int  width;
    int height;
    float scale;

};

// ===== 窗口管理类 =====
class Window {
public:
    // 初始化窗口
    static void Init(int width = 800, int height = 600, const std::string& title = "少儿编程世界") {
        InitWindow(width, height, title.c_str());
        SetTargetFPS(60);

        // 设置文本使用UTF-8编码，支持中文显示
        SetTextureFilter(GetFontDefault().texture, TEXTURE_FILTER_BILINEAR);
    }

    // 关闭窗口
    static void Close() {
        CloseWindow();
    }

    // 检查窗口是否应该关闭
    static bool ShouldClose() {
        return WindowShouldClose();
    }

    // 开始绘制
    static void BeginDraw() {
        BeginDrawing();
        ClearBackground(RAYWHITE);
        rlPushMatrix(); // 保存当前坐标系
        rlTranslatef(GetScreenWidth() / 2.0f, GetScreenHeight() / 2.0f, 0); // 移动原点到屏幕中心
    }

    // 结束绘制
    static void EndDraw() {
        rlPopMatrix(); // 恢复坐标系
        EndDrawing();
    }

    // 设置背景颜色
    static void SetBackground(Color color) {
        ClearBackground(color);
    }
};

// ===== 键盘输入 =====
namespace Keyboard {
    // 检查按键是否被按下
    bool IsKeyPressed(int key) {
        return ::IsKeyPressed(key);
    }

    // 检查按键是否被持续按下
    bool IsKeyDown(int key) {
        return ::IsKeyDown(key);
    }
}

// ===== 鼠标输入 =====
namespace Mouse {
    // 获取鼠标位置
    Vector2 GetPosition() {
        return GetMousePosition();
    }

    // 检查鼠标按键是否被按下
    bool IsButtonPressed(int button) {
        return IsMouseButtonPressed(button);
    }

    // 检查鼠标按键是否被持续按下
    bool IsButtonDown(int button) {
        return IsMouseButtonDown(button);
    }
}

#endif // ZGSPRITE_H